/**
 * 借阅管理相关的JavaScript代码
 */

$(document).ready(function() {
    // 加载借阅列表页面
    if ($("#borrow-table-body").length > 0) {
        // 检查URL参数，显示相应消息
        const urlParams = new URLSearchParams(window.location.search);
        const message = urlParams.get('message');
        const error = urlParams.get('error');
        
        if (message === 'return_success') {
            alert('图书归还成功！');
        } else if (message === 'borrow_success') {
            alert('借阅记录添加成功！');
        } else if (error === 'return_failed') {
            alert('图书归还失败，可能借阅记录不存在或状态错误');
        } else if (error === 'borrow_failed') {
            alert('借阅失败，可能图书不存在或已被借出');
        } else if (error === 'missing_id') {
            alert('缺少借阅记录ID');
        } else if (error === 'missing_book_id') {
            alert('缺少图书ID');
        } else if (error === 'missing_reader_name') {
            alert('缺少借阅者姓名');
        }
        
        loadBorrowRecords();
        
        // 搜索功能
        $("#search-btn").click(function() {
            const searchValue = $("#search-input").val();
            loadBorrowRecords(searchValue);
        });
        
        // 回车搜索
        $("#search-input").keypress(function(e) {
            if (e.which == 13) {
                loadBorrowRecords($(this).val());
            }
        });
    }
    
    // 处理添加借阅表单提交
    $("#borrow-form").submit(function(e) {
        e.preventDefault();
        saveBorrowRecord();
    });
    
    // 如果是借阅添加页面且URL包含bookId参数，加载图书信息
    if (window.location.href.indexOf("borrow_add.html") > -1) {
        const urlParams = new URLSearchParams(window.location.search);
        const bookId = urlParams.get('bookId');
        if (bookId) {
            loadBookForBorrow(bookId);
        } else {
            // 没有指定图书ID，加载所有可借阅的图书
            loadAvailableBooks();
        }
    }
});

/**
 * 加载借阅记录
 */
function loadBorrowRecords(keyword) {
    // 显示加载指示器
    $("#borrow-table-body").html("<tr><td colspan='7'>加载中...</td></tr>");
    
    // 准备查询参数
    let data = {};
    if (keyword) {
        data.keyword = keyword;
    }
    
    // 发送AJAX请求获取借阅记录
    $.ajax({
        url: "list.borrow",
        type: "GET",
        data: data,
        dataType: "json",
        success: function(response) {
            console.log("借阅记录原始响应:", response);
            
            // 检查响应中是否包含数据，处理各种可能的数据结构
            let borrowData = null;
            
            // 尝试各种可能的数据结构
            if (response.data) {
                borrowData = response.data;
            } else if (response.borrows) {
                borrowData = response.borrows;
            } else if (response.borrowRecords) {
                borrowData = response.borrowRecords; 
            } else if (response.list) {
                borrowData = response.list;
            } else if (response.rows) {
                borrowData = response.rows;
            } else if (Array.isArray(response)) {
                borrowData = response;
            } else if (response.result && Array.isArray(response.result)) {
                borrowData = response.result;
            } else if (response.results && Array.isArray(response.results)) {
                borrowData = response.results;
            } else {
                // 尝试查找任何看起来像数组的属性
                for (let key in response) {
                    if (Array.isArray(response[key])) {
                        console.log("找到可能的借阅数据数组，属性名:", key);
                        borrowData = response[key];
                        break;
                    }
                }
            }
            
            console.log("处理后的借阅数据:", borrowData);
            
            if (borrowData) {
                renderBorrowTable(borrowData);
            } else {
                alert("获取借阅记录失败：" + (response.message || "未知错误，无法解析数据结构"));
                console.error("无法从响应中提取借阅数据:", response);
                
                // 尝试将整个响应作为单个记录处理
                if (typeof response === 'object' && response !== null) {
                    console.log("尝试将响应作为单个记录处理");
                    renderBorrowTable([response]);
                }
            }
        },
        error: function(xhr, status, error) {
            alert("获取借阅记录时发生错误：" + error);
            console.error("借阅记录请求错误:", xhr.responseText);
        }
    });
}

/**
 * 为借阅加载图书信息
 */
function loadBookForBorrow(bookId) {
    $.ajax({
        url: "get.book",
        type: "GET",
        data: { id: bookId },
        dataType: "json",
        success: function(response) {
            console.log("借阅-获取图书详情响应:", response);
            // 检查响应中是否包含数据，无论success字段如何
            let bookData = null;
            if (response.data) {
                bookData = response.data;
            } else if (response.book) {
                bookData = response.book;
            } else if (!response.success && !response.message) {
                // 如果响应本身就是图书对象
                bookData = response;
            }
            
            if (bookData) {
                // 填充图书信息
                $("#book-id").val(bookData.id);
                $("#book-info").html(`
                    <div><strong>ISBN：</strong>${bookData.isbn || ''}</div>
                    <div><strong>书名：</strong>${bookData.title || ''}</div>
                    <div><strong>作者：</strong>${bookData.author || ''}</div>
                    <div><strong>出版社：</strong>${bookData.publisher || ''}</div>
                    <div><strong>分类：</strong>${bookData.category || ''}</div>
                `);
            } else {
                alert("获取图书信息失败：" + (response.message || "未知错误"));
            }
        },
        error: function(xhr, status, error) {
            alert("获取图书信息时发生错误：" + error);
            console.error(xhr.responseText);
        }
    });
}

/**
 * 加载可借阅的图书列表
 */
function loadAvailableBooks() {
    $.ajax({
        url: "available.book",
        type: "GET",
        data: {
            pageSize: 1000  // 设置较大的页大小，获取所有可借阅的图书
        },
        dataType: "json",
        success: function(response) {
            console.log("可借阅图书响应:", response);
            // 检查响应中是否包含数据，无论success字段如何
            let booksData = null;
            if (response.data) {
                booksData = response.data;
            } else if (response.books) {
                booksData = response.books;
            } else if (Array.isArray(response)) {
                booksData = response;
            }
            
            if (booksData && booksData.length > 0) {
                let options = '<option value="">请选择图书</option>';
                for (let i = 0; i < booksData.length; i++) {
                    options += `<option value="${booksData[i].id}">${booksData[i].title} (${booksData[i].author || ''})</option>`;
                }
                $("#book-select").html(options);
                
                // 监听选择变化，显示选中图书信息
                $("#book-select").change(function() {
                    const selectedBookId = $(this).val();
                    if (selectedBookId) {
                        loadBookForBorrow(selectedBookId);
                    } else {
                        $("#book-info").html('');
                    }
                });
            } else {
                $("#book-selection").html('<p>没有可借阅的图书</p>');
                alert("获取可借阅图书失败：" + (response.message || "没有可借阅的图书"));
            }
        },
        error: function(xhr, status, error) {
            alert("获取可借阅图书时发生错误：" + error);
            console.error(xhr.responseText);
        }
    });
}

/**
 * 格式化日期，将时间戳或其他日期格式转换为YYYY-MM-DD
 */
function formatDate(dateValue) {
    // 如果为空，返回空字符串
    if (!dateValue) {
        return '';
    }
    
    let date;
    
    // 如果是毫秒级时间戳（数字或数字字符串）
    if (!isNaN(dateValue) && (typeof dateValue === 'number' || !isNaN(parseInt(dateValue)))) {
        // 如果是数字字符串，先转为数字
        const timestamp = typeof dateValue === 'number' ? dateValue : parseInt(dateValue);
        date = new Date(timestamp);
    } else {
        // 否则尝试直接创建日期对象
        date = new Date(dateValue);
    }
    
    // 检查日期是否有效
    if (isNaN(date.getTime())) {
        console.error("无效的日期值:", dateValue);
        return dateValue; // 无法解析则返回原值
    }
    
    // 格式化为YYYY-MM-DD
    const year = date.getFullYear();
    const month = (date.getMonth() + 1).toString().padStart(2, '0');
    const day = date.getDate().toString().padStart(2, '0');
    
    return `${year}-${month}-${day}`;
}

/**
 * 渲染借阅记录表格
 */
function renderBorrowTable(records) {
    console.log("要渲染的借阅记录数据:", records);
    
    if (!records || records.length === 0) {
        $("#borrow-table-body").html("<tr><td colspan='7'>暂无借阅记录</td></tr>");
        return;
    }
    
    let html = "";
    
    // 计算当前日期，用于判断是否逾期
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    
    // 遍历借阅记录构建表格行
    for (let i = 0; i < records.length; i++) {
        const record = records[i];
        console.log("处理记录:", record);
        
        // 兼容多种可能的字段名 - 根据数据库结构添加更多字段名映射
        const id = record.id || record.borrowId || '';
        
        // 处理图书标题 - 可能是直接字段或需要通过book_id获取
        let bookTitle = record.bookTitle || record.book_title || record.bookName || record.book_name || '';
        // 从嵌套对象获取
        if (!bookTitle && record.book && typeof record.book === 'object') {
            // 如果book是一个对象，尝试从中获取标题
            bookTitle = record.book.title || record.book.name || '';
        }
        // 通过bookId获取
        if (!bookTitle && record.bookId) {
            bookTitle = "图书ID: " + record.bookId;
        }
        // 通过book_id获取
        if (!bookTitle && record.book_id) {
            bookTitle = "图书ID: " + record.book_id;
        }
        
        // 处理借阅人 - 匹配数据库中的reader_name字段
        const borrowerName = record.borrowerName || record.borrower_name || record.borrower || 
                           record.reader || record.readerName || record.reader_name || '';
        
        // 处理借阅日期 - 匹配数据库中的borrow_date字段
        const borrowDateRaw = record.borrowDate || record.borrow_date || record.borrowTime || 
                         record.createTime || record.createtime || '';
        // 格式化借阅日期
        const borrowDate = formatDate(borrowDateRaw);
        
        // 处理应还日期 - 匹配数据库中的return_date字段
        const returnDateRaw = record.returnDate || record.return_date || record.shouldReturnDate || 
                         record.should_return_date || '';
        // 格式化应还日期
        const returnDate = formatDate(returnDateRaw);
        
        // 处理实际归还日期 - 匹配数据库中的actual_return_date字段
        const actualReturnDateRaw = record.actualReturnDate || record.actual_return_date || 
                               record.returnTime || '';
        // 格式化实际归还日期
        const actualReturnDate = formatDate(actualReturnDateRaw);
        
        console.log("解析后的字段:", {id, bookTitle, borrowerName, borrowDate, returnDate, actualReturnDate});
        
        // 处理状态
        let returnDateObj;
        try {
            returnDateObj = returnDateRaw ? new Date(returnDateRaw) : null;
        } catch (e) {
            console.error("无法解析日期:", returnDateRaw, e);
            returnDateObj = null;
        }
        
        let status = '';
        let statusClass = '';
        
        // 直接使用数据库中的status字段
        if (record.status) {
            status = record.status;
            if (status.includes('逾期') || status.includes('overdue')) {
                statusClass = 'overdue';
            }
        } else {
            // 根据日期计算状态
            if (actualReturnDateRaw) {
                status = '已归还';
            } else {
                if (returnDateObj && today > returnDateObj) {
                    status = '逾期未还';
                    statusClass = 'overdue';
                } else {
                    status = '借阅中';
                }
            }
        }
        
        html += `<tr>
            <td>${id}</td>
            <td>${bookTitle}</td>
            <td>${borrowerName}</td>
            <td>${borrowDate}</td>
            <td>${returnDate}</td>
            <td class="${statusClass}">${status}</td>
            <td>
                ${(!actualReturnDateRaw && status !== '已归还') ? 
                    `<button class="btn-small" onclick="returnBook(${id})">归还</button>` : 
                    ''}
            </td>
        </tr>`;
    }
    
    // 更新表格内容
    $("#borrow-table-body").html(html);
    
    // 如果表格仍然有空白单元格，输出一条警告消息
    if (html.includes('<td></td>')) {
        console.warn("表格中存在空白单元格，可能是字段名称不匹配造成的。实际数据:", records);
        // 如果控制台中有数据，请检查第一条记录的字段
        if (records && records.length > 0) {
            console.warn("第一条记录的字段名:", Object.keys(records[0]).join(", "));
        }
    }
}

/**
 * 保存借阅记录
 */
function saveBorrowRecord() {
    // 获取表单数据
    const borrowData = {
        bookId: $("#book-id").val() || $("#book-select").val(),
        borrowerName: $("#borrower-name").val(),
        borrowerPhone: $("#borrower-phone").val(),
        borrowDate: $("#borrow-date").val(),
        returnDate: $("#return-date").val()
    };
    
    // 确保bookId是数字
    if (borrowData.bookId) {
        borrowData.bookId = parseInt(borrowData.bookId);
    }
    
    // 验证必填字段
    if (!borrowData.bookId) {
        alert("请选择要借阅的图书");
        return;
    }
    if (!borrowData.borrowerName) {
        alert("请输入借阅人姓名");
        return;
    }
    
    // 使用表单提交
    const form = $('<form></form>')
        .attr('method', 'post')
        .attr('action', 'add.borrow');
    
    // 添加表单字段
    for (const key in borrowData) {
        if (borrowData[key]) {
            $('<input />')
                .attr('type', 'hidden')
                .attr('name', key)
                .attr('value', borrowData[key])
                .appendTo(form);
        }
    }
    
    // 添加返回页面
    $('<input />')
        .attr('type', 'hidden')
        .attr('name', 'returnPage')
        .attr('value', 'borrow_page.html')
        .appendTo(form);
    
    // 将表单添加到页面并提交
    form.appendTo('body').submit();
}

/**
 * 归还图书
 */
function returnBook(borrowId) {
    if (confirm("确认归还此图书？")) {
        console.log("尝试归还图书ID:", borrowId);
        
        // 直接使用表单提交方式
        const form = $('<form></form>')
            .attr('method', 'post')
            .attr('action', 'return.borrow');
        
        // 尝试各种可能的参数名称
        $('<input />')
            .attr('type', 'hidden')
            .attr('name', 'borrowId')
            .attr('value', borrowId)
            .appendTo(form);
            
        $('<input />')
            .attr('type', 'hidden')
            .attr('name', 'id')
            .attr('value', borrowId)
            .appendTo(form);
            
        $('<input />')
            .attr('type', 'hidden')
            .attr('name', 'recordId')
            .attr('value', borrowId)
            .appendTo(form);
        
        // 添加当前日期作为归还日期
        const today = new Date();
        const formattedDate = today.getFullYear() + '-' + 
                             (today.getMonth() + 1).toString().padStart(2, '0') + '-' + 
                             today.getDate().toString().padStart(2, '0');
                             
        $('<input />')
            .attr('type', 'hidden')
            .attr('name', 'actualReturnDate')
            .attr('value', formattedDate)
            .appendTo(form);
            
        $('<input />')
            .attr('type', 'hidden')
            .attr('name', 'actual_return_date')
            .attr('value', formattedDate)
            .appendTo(form);
        
        // 添加状态值
        $('<input />')
            .attr('type', 'hidden')
            .attr('name', 'status')
            .attr('value', '已归还')
            .appendTo(form);
            
        // 添加返回页面
        $('<input />')
            .attr('type', 'hidden')
            .attr('name', 'returnPage')
            .attr('value', 'borrow_page.html')
            .appendTo(form);
        
        // 将表单添加到页面并直接提交
        form.appendTo('body').submit();
    }
} 